package lwk.juc.notify;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author:lwk
 * @create: 2022-08-11 20:28
 * @Description: 虚假唤醒
 *
 * 线程等待的条件应该使用while多次判断，而不是用if只判断一次，如本例中：同时存在多个消费者和生产者。
 *
 * 例如：生产者线程A生产完成之后，理想状态下是只唤醒一个处于wait状态的消费者B或者D去消费。但是实际情况是BD两个线程都会被唤醒，
 * 因为BD的业务判断条件使用的是if,就会导致BD同时消费。另外生产者线程C也会被唤醒，进行生产。
 *
 * 所以应当用while进行多次判断，如果不符合条件，继续等待唤醒。
 *
 */
public class JUCShamNotifyDemo {

    public static void main(String[] args) {

        DataOp2 dataOp = new DataOp2();

        new Thread(()->{

            for (int i = 0; i < 100; i++) {
                dataOp.add();
            }

        },"A").start();

        new Thread(()->{

            for (int i = 0; i < 10; i++) {
                dataOp.del();
            }

        },"B").start();

        new Thread(()->{

            for (int i = 0; i < 100; i++) {
                dataOp.add();
            }

        },"C").start();

        new Thread(()->{

            for (int i = 0; i < 10; i++) {
                dataOp.del();
            }

        },"D").start();
    }

}


class DataOp2 {

    int number;
    Lock lock = new ReentrantLock();

    Condition condition = lock.newCondition();

    // 模拟生产者
    public void add() {
        lock.lock();
        try {
            // 不等于0的时候等待
            if (number!=0) {
                condition.await();
            }
            // 等于0的时候加
            System.out.println(Thread.currentThread().getName()+"==>"+number++);
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    // 模拟消费者
    public void del(){
        lock.lock();
        try {
            // 等于0的时候等待
            if (number==0) {
                condition.await();
            }
            // 不等于0的时候减
            System.out.println(Thread.currentThread().getName()+"==>"+number--);
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}